home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / mach / ds5000.md / ioctl.c < prev    next >
C/C++ Source or Header  |  1991-03-05  |  15KB  |  589 lines
  1. /* 
  2.  * ioctl.c --
  3.  *
  4.  *    Procedure to map from Unix ioctl system call to Sprite.
  5.  *
  6.  * Copyright 1986 Regents of the University of California
  7.  * All rights reserved.
  8.  */
  9.  
  10. #ifndef lint
  11. static char rcsid[] = "$Header: /sprite/src/kernel/mach/ds5000.md/RCS/ioctl.c,v 1.2 91/03/05 15:06:39 jhh Exp $ SPRITE (Berkeley)";
  12. #endif not lint
  13.  
  14. #include <user/sys/ioctl.h>
  15. #include <user/sys/termios.h>
  16. #include <user/netEther.h>
  17. #include <sprite.h>
  18. #include <compatInt.h>
  19. #include <user/dev/tty.h>
  20. #include <user/dev/net.h>
  21. #include <user/dev/graphics.h>
  22. #include <fs.h>
  23. #include <errno.h>
  24.  
  25. #include <user/sys/types.h>
  26. #include <fcntl.h>
  27. #include <user/sys/socket.h>
  28. #include <user/sys/ttychars.h>
  29. #include <user/sys/ttydev.h>
  30. #include <user/net/route.h>
  31. #include <user/net/if.h>
  32. #include <user/sys/time.h>
  33. #include <machInt.h>
  34. #include <mach.h>
  35. #include <net.h>
  36.  
  37. #ifdef __STDC__
  38. static void DecodeRequest _ARGS_((int request));
  39. #else
  40. #define const
  41. static void DecodeRequest();
  42. #endif
  43.  
  44. #ifdef notdef
  45. int compatTapeIOCMap[] = {
  46.     IOC_TAPE_WEOF,         /* 0, MTWEOF */
  47.     IOC_TAPE_SKIP_FILES,    /* 1, MTFSF */
  48.     IOC_TAPE_BACKUP_FILES,    /* 2, MTBSF */
  49.     IOC_TAPE_SKIP_BLOCKS,    /* 3, MTFSR */
  50.     IOC_TAPE_BACKUP_BLOCKS,    /* 4, MTBSR */
  51.     IOC_TAPE_REWIND,         /* 5, MTREW */
  52.     IOC_TAPE_OFFLINE,         /* 6, MTOFFL */
  53.     IOC_TAPE_NO_OP,        /* 7, MTNOP */
  54.     IOC_TAPE_RETENSION,        /* 8, MTRETEN */
  55.     IOC_TAPE_ERASE,        /* 9, MTERASE */
  56. };
  57. #endif
  58.  
  59. unsigned ifcBuf[16] = {
  60. 0x306573, 0x8011a4e0, 0x1, 0x0,
  61. 0x2, 0x21100110, 0x0, 0x0,
  62. 0x306f6c, 0x0, 0x0, 0xf5c0,
  63. 0x2, 0x0100007f, 0x0, 0x0,
  64. };
  65.  
  66.  
  67. /*
  68.  *----------------------------------------------------------------------
  69.  *
  70.  * ioctl --
  71.  *
  72.  *    Compat procedure for Unix ioctl call. This procedure usually does
  73.  *    nothing.
  74.  *
  75.  * Results:
  76.  *    Error code returned, SUCCESS if no error.
  77.  *
  78.  * Side effects:
  79.  *    None.
  80.  *
  81.  *----------------------------------------------------------------------
  82.  */
  83. int
  84. MachUNIXIoctl(fd, request, buf)
  85.     int        fd;
  86.     int        request;
  87.     char *    buf;
  88. {
  89.     ReturnStatus    status;
  90.     Address        usp;
  91.     extern Mach_State    *machCurStatePtr;
  92.  
  93.     usp = (Address)machCurStatePtr->userState.regState.regs[SP];
  94.     switch (request) {
  95.  
  96.     /*
  97.      * Generic calls:
  98.      */
  99.  
  100.     case FIOCLEX: {
  101.         /*
  102.          * Set the close-on-exec bit for the file.
  103.          * Buf is not used.
  104.          */
  105.  
  106.         int flag = IOC_CLOSE_ON_EXEC;
  107.         usp -= sizeof(flag);
  108.         status = Vm_CopyOut(sizeof(flag), (Address)&flag, usp);
  109.         if (status != SUCCESS) {
  110.             break;
  111.         }
  112.         status = Fs_IOControlStub(fd, IOC_SET_BITS, 
  113.                       sizeof(flag), usp, 0, (Address) NULL);
  114.         }
  115.         break;
  116.  
  117.     case FIONCLEX: {
  118.         /*
  119.          * Clear the close-on-exec bit for the file.
  120.          * Buf is not used.
  121.          */
  122.  
  123.         int flag = IOC_CLOSE_ON_EXEC;
  124.         usp -= sizeof(flag);
  125.         status = Vm_CopyOut(sizeof(flag), (Address)&flag, usp);
  126.         if (status != SUCCESS) {
  127.             break;
  128.         }
  129.         status = Fs_IOControlStub(fd, IOC_CLEAR_BITS, 
  130.                       sizeof(flag), usp, 0, (Address) NULL);
  131.         }
  132.         break;
  133.  
  134.     case FIONREAD:
  135.         status = Fs_IOControlStub(fd, IOC_NUM_READABLE, 0, (Address) NULL,
  136.                       sizeof(int), buf);
  137.         break;
  138.  
  139.         case FIONBIO: {
  140.         /*
  141.          * Set or clear the non-blocking I/O bit for the file.
  142.          */
  143.  
  144.         int flag = IOC_NON_BLOCKING;
  145.         int setBit;
  146.  
  147.         if (Vm_CopyIn(4, buf, &setBit) != SUCCESS) {
  148.             status = SYS_ARG_NOACCESS;
  149.             break;
  150.         }
  151.         usp -= sizeof(flag);
  152.         status = Vm_CopyOut(sizeof(flag), (Address)&flag, usp);
  153.         if (status != SUCCESS) {
  154.             break;
  155.         }
  156.         if (setBit) {
  157.             status = Fs_IOControlStub(fd, IOC_SET_BITS, 
  158.                 sizeof(flag), usp, 0, (Address) NULL);
  159.         } else {
  160.             status = Fs_IOControlStub(fd, IOC_CLEAR_BITS, 
  161.                 sizeof(flag), usp, 0, (Address) NULL);
  162.         }
  163.         }
  164.         break;
  165.  
  166.     case FIOASYNC: {
  167.         /*
  168.          * Set or clear the asynchronous I/O bit for the file.
  169.          */
  170.  
  171.         int flag = IOC_ASYNCHRONOUS;
  172.         int setBit;
  173.  
  174.         if (Vm_CopyIn(4, buf, &setBit) != SUCCESS) {
  175.             status = SYS_ARG_NOACCESS;
  176.             break;
  177.         }
  178.         usp -= sizeof(flag);
  179.         status = Vm_CopyOut(sizeof(flag), (Address)&flag, usp);
  180.         if (status != SUCCESS) {
  181.             break;
  182.         }
  183.         if (setBit) {
  184.             status = Fs_IOControlStub(fd, IOC_SET_BITS, 
  185.                 sizeof(flag), usp, 0, (Address) NULL);
  186.         } else {
  187.             status = Fs_IOControlStub(fd, IOC_CLEAR_BITS, 
  188.                 sizeof(flag), usp, 0, (Address) NULL);
  189.         }
  190.         }
  191.         break;
  192.  
  193.  
  194.     case FIOGETOWN:
  195.     case SIOCGPGRP:
  196.     case TIOCGPGRP: {
  197.         Ioc_Owner owner;
  198.  
  199.         usp -= sizeof(owner);
  200.         status = Fs_IOControlStub(fd, IOC_GET_OWNER, 0,
  201.                     (Address)NULL, sizeof(Ioc_Owner), usp);
  202.         if (status == SUCCESS) {
  203.             (void)Vm_CopyIn(sizeof(owner), usp, (Address)&owner);
  204.             status = Vm_CopyOut(sizeof(int), &owner.id, buf);
  205.         }
  206.         }
  207.         break;
  208.  
  209.     case FIOSETOWN:
  210.     case SIOCSPGRP:
  211.     case TIOCSPGRP: {
  212.         Ioc_Owner owner;
  213.  
  214.         status = Vm_CopyIn(sizeof(int), buf, &owner.id);
  215.         if (status != SUCCESS) {
  216.         break;
  217.         }
  218.         owner.procOrFamily = IOC_OWNER_FAMILY;
  219.         usp -= sizeof(owner);
  220.         status = Vm_CopyOut(sizeof(owner), (Address)&owner, usp);
  221.         if (status != SUCCESS) {
  222.         break;
  223.         }
  224.         status = Fs_IOControlStub(fd, IOC_SET_OWNER, sizeof(Ioc_Owner),
  225.                       usp, 0, (Address)NULL);
  226.         break;
  227.     }
  228.  
  229.     /* 
  230.      * Tty-related calls:
  231.      */
  232.  
  233.     case TIOCGETP:
  234.         status = Fs_IOControlStub(fd, IOC_TTY_GET_PARAMS, 0, (Address) NULL,
  235.             sizeof(struct sgttyb), (Address) buf);
  236.         break;
  237.     case TIOCSETP:
  238.         status = Fs_IOControlStub(fd, IOC_TTY_SET_PARAMS, sizeof(struct sgttyb),
  239.             (Address) buf, 0, (Address) NULL);
  240.         break;
  241.     case TIOCSETN:
  242.         status = Fs_IOControlStub(fd, IOC_TTY_SETN, sizeof(struct sgttyb),
  243.             (Address) buf, 0, (Address) NULL);
  244.         break;
  245.     case TIOCEXCL:
  246.         status = Fs_IOControlStub(fd, IOC_TTY_EXCL, 0, (Address) NULL,
  247.             0, (Address) NULL);
  248.         break;
  249.     case TIOCNXCL:
  250.         status = Fs_IOControlStub(fd, IOC_TTY_NXCL, 0, (Address) NULL,
  251.             0, (Address) NULL);
  252.         break;
  253.     case TIOCHPCL:
  254.         status = Fs_IOControlStub(fd, IOC_TTY_HUP_ON_CLOSE, 0,
  255.             (Address) NULL, 0, (Address) NULL);
  256.         break;
  257.     case TIOCFLUSH:
  258.         status = Fs_IOControlStub(fd, IOC_TTY_FLUSH, sizeof(int),
  259.             (Address) buf, 0, (Address) NULL);
  260.         break;
  261.     case TIOCSTI:
  262.         status = Fs_IOControlStub(fd, IOC_TTY_INSERT_CHAR, sizeof(char),
  263.             (Address) buf, 0, (Address) NULL);
  264.         break;
  265.     case TIOCSBRK:
  266.         status = Fs_IOControlStub(fd, IOC_TTY_SET_BREAK, 0,
  267.             (Address) NULL, 0, (Address) NULL);
  268.         break;
  269.     case TIOCCBRK:
  270.         status = Fs_IOControlStub(fd, IOC_TTY_CLEAR_BREAK, 0,
  271.             (Address) NULL, 0, (Address) NULL);
  272.         break;
  273.     case TIOCSDTR:
  274.         status = Fs_IOControlStub(fd, IOC_TTY_SET_DTR, 0, 
  275.             (Address) NULL, 0, (Address) NULL);
  276.         break;
  277.     case TIOCCDTR:
  278.         status = Fs_IOControlStub(fd, IOC_TTY_CLEAR_DTR, 0,
  279.             (Address) NULL, 0, (Address) NULL);
  280.         break;
  281.     case TIOCGETC:
  282.         status = Fs_IOControlStub(fd, IOC_TTY_GET_TCHARS, 0, (Address) NULL,
  283.             sizeof(struct tchars), (Address) buf);
  284.         break;
  285.     case TIOCSETC:
  286.         status = Fs_IOControlStub(fd, IOC_TTY_SET_TCHARS,
  287.             sizeof(struct tchars), (Address) buf, 0, (Address) NULL);
  288.         break;
  289.     case TIOCGLTC:
  290.         status = Fs_IOControlStub(fd, IOC_TTY_GET_LTCHARS, 0, (Address) NULL,
  291.             sizeof(struct ltchars), (Address) buf);
  292.         break;
  293.     case TIOCSLTC:
  294.         status = Fs_IOControlStub(fd, IOC_TTY_SET_LTCHARS,
  295.             sizeof(struct ltchars), (Address) buf, 0, (Address) NULL);
  296.         break;
  297.     case TIOCLBIS:
  298.         status = Fs_IOControlStub(fd, IOC_TTY_BIS_LM,
  299.             sizeof(int), (Address) buf, 0, (Address) NULL);
  300.         break;
  301.     case TIOCLBIC:
  302.         status = Fs_IOControlStub(fd, IOC_TTY_BIC_LM,
  303.             sizeof(int), (Address) buf, 0, (Address) NULL);
  304.         break;
  305.     case TIOCLSET:
  306.         status = Fs_IOControlStub(fd, IOC_TTY_SET_LM,
  307.             sizeof(int), (Address) buf, 0, (Address) NULL);
  308.         break;
  309.     case TIOCLGET:
  310.         status = Fs_IOControlStub(fd, IOC_TTY_GET_LM, 0, (Address) NULL,
  311.             sizeof(int), (Address) buf);
  312.         break;
  313.     case TIOCGETD:
  314.         status = Fs_IOControlStub(fd, IOC_TTY_GET_DISCIPLINE, 0,
  315.             (Address) NULL, sizeof(int), (Address) buf);
  316.         break;
  317.     case TIOCSETD:
  318.         status = Fs_IOControlStub(fd, IOC_TTY_SET_DISCIPLINE,
  319.         sizeof(int), (Address) buf, 0, (Address) NULL);
  320.         break;
  321.  
  322.     case SIOCATMARK:
  323.         status = Fs_IOControlStub(fd, IOC_NET_IS_OOB_DATA_NEXT,
  324.                 0, (Address) NULL, sizeof(int), (Address) buf);
  325.         break;
  326.  
  327.         case TCGETS:
  328.         status = Fs_IOControlStub(fd, IOC_TTY_GET_TERMIO,
  329.         0, (Address) NULL, sizeof(struct termios), (Address) buf);
  330.         break;
  331.  
  332.         case TCSETS:
  333.         status = Fs_IOControlStub(fd, IOC_TTY_SET_TERMIO,
  334.         sizeof(struct termios), (Address) buf, 0, (Address) NULL);
  335.         break;
  336.  
  337.     case TIOCGWINSZ:
  338.         status = Fs_IOControlStub(fd, IOC_TTY_GET_WINDOW_SIZE,
  339.         0, (Address) NULL, sizeof(struct winsize), (Address) buf);
  340.         break;
  341.  
  342.         case TIOCSWINSZ:
  343.         status = Fs_IOControlStub(fd, IOC_TTY_SET_WINDOW_SIZE,
  344.         sizeof(struct winsize), (Address) buf, 0, (Address) NULL);
  345.         break;
  346.     /*
  347.      * Graphics requests.
  348.      */
  349.     case QIOCGINFO:
  350.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_GET_INFO,
  351.         0, (Address) NULL, sizeof(DevScreenInfo *), (Address)buf);
  352.         break;
  353.     case QIOCPMSTATE:
  354.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_MOUSE_POS,
  355.         sizeof(DevCursor), (Address) buf, 0, (Address)NULL);
  356.         break;
  357.     case QIOWCURSORCOLOR:
  358.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_CURSOR_COLOR,
  359.         sizeof(unsigned int [6]), (Address) buf, 0, (Address)NULL);
  360.         break;
  361.     case QIOCINIT:
  362.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_INIT_SCREEN,
  363.         0, (Address) NULL, 0, (Address)NULL);
  364.         break;
  365.     case QIOCKPCMD:
  366.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_KBD_CMD,
  367.         sizeof(DevKpCmd), (Address) buf, 0, (Address)NULL);
  368.         break;
  369.     case QIOCADDR:
  370.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_GET_INFO_ADDR,
  371.         0, (Address) NULL, sizeof(DevScreenInfo *), (Address)buf);
  372.         break;
  373.     case QIOWCURSOR:
  374.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_CURSOR_BIT_MAP,
  375.         sizeof(short[32]), (Address) buf, 0, (Address)NULL);
  376.         break;
  377.     case QIOKERNLOOP:
  378.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_KERN_LOOP,
  379.         0, (Address) NULL, 0, (Address)NULL);
  380.         break;
  381.     case QIOKERNUNLOOP:
  382.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_KERN_UNLOOP,
  383.         0, (Address) NULL, 0, (Address)NULL);
  384.         break;
  385.     case QIOVIDEOON:
  386.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_VIDEO_ON,
  387.         0, (Address) NULL, 0, (Address)NULL);
  388.         break;
  389.     case QIOVIDEOOFF:
  390.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_VIDEO_OFF,
  391.         0, (Address) NULL, 0, (Address)NULL);
  392.         break;
  393.     case QIOSETCMAP:
  394.         status = Fs_IOControlStub(fd, IOC_GRAPHICS_COLOR_MAP,
  395.         sizeof(DevColorMap), (Address) buf, 0, (Address)NULL);
  396.         break;
  397.     case SIOCGIFCONF: {
  398.         /*
  399.          * Fake the ifconfig ioctl.  This is a hack done for X.  
  400.          * A more general implementation is probably needed.
  401.          */
  402.         struct ifconf ifc;
  403.         struct ifreq   ifreq;
  404.         extern int      machHostID;
  405.         int          *intPtr;
  406.  
  407.         status = Vm_CopyIn(sizeof(struct ifconf), buf, (Address)&ifc);
  408.         if (status != SUCCESS) {
  409.         return(status);
  410.         }
  411.  
  412.         if (ifc.ifc_len < 32) {
  413.         status = SYS_INVALID_ARG;
  414.         break;
  415.         }
  416.         /*
  417.          * We give a length of 32 and put in the request buffer 
  418.          * the name ("se0"), followed by the family (AF_INET), 
  419.          * and finally our internet address.
  420.          */
  421.         ifc.ifc_len = 32;
  422.         strcpy(ifreq.ifr_name, "se0");
  423.         intPtr = (int *)&ifreq.ifr_ifru;
  424.         *intPtr = AF_INET;
  425.         *(intPtr + 1) = machHostID;
  426.  
  427.         status = Vm_CopyOut(sizeof(struct ifconf), (Address)&ifc, buf);
  428.         status = Vm_CopyOut(32, (Address)&ifreq,
  429.                 (Address)ifc.ifc_ifcu.ifcu_req);
  430.         break;
  431.     }
  432.  
  433.  
  434.     case SIOCRPHYSADDR: {
  435.         /* Get the ethernet address. */
  436.         Net_Interface *interPtr;
  437.         struct ifdevea *p;
  438.         Net_EtherAddress *etherAddressPtr;
  439.  
  440.         interPtr = Net_GetInterface(NET_NETWORK_ETHER, 0);
  441.         etherAddressPtr = &interPtr->netAddress[NET_PROTO_RAW].ether;
  442.  
  443.         p = (struct ifdevea *) buf;
  444.         p->default_pa[0] = p->current_pa[0] = etherAddressPtr->byte1;
  445.         p->default_pa[1] = p->current_pa[1] = etherAddressPtr->byte2;
  446.         p->default_pa[2] = p->current_pa[2] = etherAddressPtr->byte3;
  447.         p->default_pa[3] = p->current_pa[3] = etherAddressPtr->byte4;
  448.         p->default_pa[4] = p->current_pa[4] = etherAddressPtr->byte5;
  449.         p->default_pa[5] = p->current_pa[5] = etherAddressPtr->byte6;
  450.         status = SUCCESS;
  451.  
  452.         }
  453.         break;
  454.  
  455.     /*
  456.      * Unknown requests:
  457.      */
  458.  
  459.     default:
  460.         DecodeRequest(request);
  461.         status = SYS_INVALID_ARG;
  462.     }
  463.     return(status);
  464. }
  465.  
  466.  
  467.  
  468. /*
  469.  *----------------------------------------------------------------------
  470.  *
  471.  * DecodeRequest --
  472.  *
  473.  *    Takes a UNIX ioctl request and prints the name of the request
  474.  *    on the standard error file.
  475.  *
  476.  * Results:
  477.  *    None.
  478.  *
  479.  * Side effects:
  480.  *    None.
  481.  *
  482.  *----------------------------------------------------------------------
  483.  */
  484.  
  485. typedef struct {
  486.     char *name;
  487.     int     request;
  488. } RequestName;
  489.  
  490. static void
  491. DecodeRequest(request)
  492.     int request;
  493. {
  494.     register int i;
  495.     /*
  496.      * The following list contains all the ioctls in 
  497.      * /usr/include/sys/ioctl.h (SunOS 3.2), and
  498.      * /usr/include/sys/termios.h (SunOS 4.0).
  499.      */
  500.     const static RequestName mapping[] = {
  501.     {"TIOCGETD",    TIOCGETD},
  502.     {"TIOCSETD",    TIOCSETD},
  503.     {"TIOCHPCL",    TIOCHPCL},
  504.     {"TIOCMODG",    TIOCMODG},
  505.     {"TIOCMODS",    TIOCMODS},
  506.     {"TIOCGETP",    TIOCGETP},
  507.     {"TIOCSETP",    TIOCSETP},
  508.     {"TIOCSETN",    TIOCSETN},
  509.     {"TIOCEXCL",    TIOCEXCL},
  510.     {"TIOCNXCL",    TIOCNXCL},
  511.     {"TIOCFLUSH",    TIOCFLUSH},
  512.     {"TIOCSETC",    TIOCSETC},
  513.     {"TIOCGETC",    TIOCGETC},
  514.     {"TIOCLBIS",    TIOCLBIS},
  515.     {"TIOCLBIC",    TIOCLBIC},
  516.     {"TIOCLSET",    TIOCLSET},
  517.     {"TIOCLGET",    TIOCLGET},
  518.     {"TIOCSBRK",    TIOCSBRK},
  519.     {"TIOCCBRK",    TIOCCBRK},
  520.     {"TIOCSDTR",    TIOCSDTR},
  521.     {"TIOCCDTR",    TIOCCDTR},
  522.     {"TIOCSLTC",    TIOCSLTC},
  523.     {"TIOCGLTC",    TIOCGLTC},
  524.     {"TIOCOUTQ",    TIOCOUTQ},
  525.     {"TIOCSTI",    TIOCSTI},
  526.     {"TIOCNOTTY",    TIOCNOTTY},
  527.     {"TIOCPKT",    TIOCPKT},
  528.     {"TIOCSTOP",    TIOCSTOP},
  529.     {"TIOCSTART",    TIOCSTART},
  530.     {"TIOCMSET",    TIOCMSET},
  531.     {"TIOCMBIS",    TIOCMBIS},
  532.     {"TIOCMBIC",    TIOCMBIC},
  533.     {"TIOCMGET",    TIOCMGET},
  534.     {"TIOCREMOTE",    TIOCREMOTE},
  535.     {"TIOCGWINSZ",    TIOCGWINSZ},
  536.     {"TIOCSWINSZ",    TIOCSWINSZ},
  537.     {"TIOCUCNTL",    TIOCUCNTL},
  538.     {"TIOCCONS",    TIOCCONS},
  539.     {"TIOCSSIZE",    TIOCSSIZE},
  540.     {"TIOCGSIZE",    TIOCGSIZE},
  541.     {"SIOCSHIWAT",    SIOCSHIWAT},
  542.     {"SIOCGHIWAT",    SIOCGHIWAT},
  543.     {"SIOCSLOWAT",    SIOCSLOWAT},
  544.     {"SIOCGLOWAT",    SIOCGLOWAT},
  545.     {"SIOCADDRT",    SIOCADDRT},
  546.     {"SIOCDELRT",    SIOCDELRT},
  547.     {"SIOCSIFADDR",    SIOCSIFADDR},
  548.     {"SIOCGIFADDR",    SIOCGIFADDR},
  549.     {"SIOCSIFDSTADDR",    SIOCSIFDSTADDR},
  550.     {"SIOCGIFDSTADDR",    SIOCGIFDSTADDR},
  551.     {"SIOCSIFFLAGS",    SIOCSIFFLAGS},
  552.     {"SIOCGIFFLAGS",    SIOCGIFFLAGS},
  553.     {"SIOCGIFCONF",    SIOCGIFCONF},
  554.     {"SIOCGIFBRDADDR",    SIOCGIFBRDADDR},
  555.     {"SIOCSIFBRDADDR",    SIOCSIFBRDADDR},
  556.     {"SIOCGIFNETMASK",    SIOCGIFNETMASK},
  557.     {"SIOCSIFNETMASK",    SIOCSIFNETMASK},
  558.     {"SIOCGIFMETRIC",    SIOCGIFMETRIC},
  559.     {"SIOCSIFMETRIC",    SIOCSIFMETRIC},
  560.     {"SIOCSARP",    SIOCSARP},
  561.     {"SIOCGARP",    SIOCGARP},
  562.     {"SIOCDARP",    SIOCDARP},
  563.     {"TCXONC",      TCXONC},
  564.     {"TCFLSH",      TCFLSH},
  565.     {"TCGETS",      TCGETS},
  566.     {"TCSETS",      TCSETS},
  567.     };
  568.  
  569.     if ((request == TIOCGSIZE) || (request == TIOCGWINSZ)) {
  570.     /*
  571.      * Special-case TIOCGSIZE since every visually-oriented program
  572.      * uses it and it's annoying to constantly get the messages.
  573.      */
  574.     return;
  575.     }
  576.  
  577.     /*
  578.      * For now search the list linearly. It's slow but simple...
  579.      */
  580.     for (i = sizeof(mapping)/sizeof(*mapping) - 1; i >= 0; --i) {
  581.     if (request == mapping[i].request) {
  582.         printf("ioctl: bad command %s\n", mapping[i].name);
  583.         return;
  584.     }
  585.     }
  586.     printf("ioctl: bad command 0x%x\n", request);
  587.     return;
  588. }
  589.